Updated raid 6 implementation

ABSTRACT

A system, computer program product, and computer-executable method of implementing a redundant array of independent disk (RAID) system wherein the RAID, the computer-executable method comprises storing data storage blocks arranged in a first plurality of data rows and a second plurality of data columns and storing parity data in defined parity blocks, wherein a portion of the defined parity blocks include column parity data.

A portion of the disclosure of this patent document may contain commandformats and other computer language listings, all of which are subjectto copyright protection. The copyright owner has no objection to thefacsimile reproduction by anyone of the patent document or the patentdisclosure, as it appears in the Patent and Trademark Office patent fileor records, but otherwise reserves all copyright rights whatsoever.

TECHNICAL FIELD

This invention relates to data storage.

BACKGROUND

Computer systems are constantly improving in terms of speed,reliability, and processing capability. As is known in the art, computersystems which process and store large amounts of data typically includea one or more processors in communication with a shared data storagesystem in which the data is stored. The data storage system may includeone or more storage devices, usually of a fairly robust nature anduseful for storage spanning various temporal requirements, e.g., diskdrives. The one or more processors perform their respective operationsusing the storage system. Mass storage systems (MSS) typically includean array of a plurality of disks with on-board intelligent andcommunications electronics and software for making the data on the disksavailable.

Companies that sell data storage systems and the like are very concernedwith providing customers with an efficient data storage solution thatminimizes cost while meeting customer data storage needs. It would bebeneficial for such companies to have a way for reducing the complexityof implementing data storage.

SUMMARY

A system, computer program product, and computer-executable method ofimplementing a redundant array of independent disk (RAID) system whereinthe RAID, the computer-executable method comprises storing data storageblocks arranged in a first plurality of data rows and a second pluralityof data columns and storing parity data in defined parity blocks,wherein a portion of the defined parity blocks include column paritydata.

BRIEF DESCRIPTION OF THE DRAWINGS

Objects, features, and advantages of embodiments disclosed herein may bebetter understood by referring to the following description inconjunction with the accompanying drawings. The drawings are not meantto limit the scope of the claims included herewith. For clarity, notevery element may be labeled in every figure. The drawings are notnecessarily to scale, emphasis instead being placed upon illustratingembodiments, principles, and concepts. Thus, features and advantages ofthe present disclosure will become more apparent from the followingdetailed description of exemplary embodiments thereof taken inconjunction with the accompanying drawings in which:

FIG. 1 is a simplified illustration of a redundant array of independentdisk (RAID) system, in accordance with an embodiment of the presentdisclosure;

FIG. 2 is a block diagram showing a distribution of data blocks in theRAID 6 memory array of FIG. 1;

FIG. 3 is a schematic block diagram showing in greater detail thedistribution of data blocks of FIG. 2;

FIG. 4 is a simplified illustration of a Redundant Array of IndependentDisks (RAID) 6 implementation on a Raid system, in accordance to anembodiment of the present disclosure;

FIGS. 5A and 5B are simplified illustrations of a striping pattern of aRedundant Array of Independent Disk (RAID) implementation, in accordanceto an embodiment of the present disclosure;

FIG. 6 is a simplified flowchart of a method of storing data within aRAID system as shown in FIG. 4, in accordance with an embodiment of thepresent disclosure;

FIG. 7 is an example of an embodiment of an apparatus that may utilizethe techniques described herein, in accordance with an embodiment of thepresent disclosure; and

FIG. 8 is an example of a method embodied on a computer readable storagemedium that may utilize the techniques described herein, in accordancewith an embodiment of the present disclosure.

Like reference symbols in the various drawings indicate like elements.

DETAILED DESCRIPTION

Traditionally, standard RAID 6 scheme implementations are complicated.Generally, recovering one or more failed disks causes a high amount ofread latency. Typically, much of the read latency is caused by the extraQ, which adds complexity to a RAID implementation as the extra Q breaksthe column's layout of stripes on a disk and requires special handlingin case of a Q disk rebuild. Traditionally, known methods to avoidkeeping extra Q introduces disadvantages upon a recovery upon data diskand row-parity disk failure, where each read requires reading a largepart of the data stripe before recovering a single data block.Conventionally, improvements to the RAID 6 Scheme would be beneficial tothe data storage industry.

In many embodiments, the current disclosure may enable implementation ofa simplified RAID 6 scheme. In various embodiments, the currentdisclosure may enable implementation of a RAID 6 scheme that may reduceread latency in the case of a single or a double disk failure. Incertain embodiments, the current disclosure may enable recovery withoutrequiring reading a large part of a data stripe within a RAID 6 schemebefore recovering a single data block of a failed disk.

Redundant Array of Independent Disks (RAID) System

Refer to the example embodiment of FIG. 1. FIG. 1 is a simplifiedillustration of a redundant array of independent disk (RAID) system, inaccordance with an embodiment of the present disclosure. RAID system 100includes a controller 105 and an array 135 of data storage disks, inthis example five data disks (D0-D4).

The controller 105 includes a data write unit 110 for writing initialdata into the array, an update unit 115 for updating existing data inthe array, a single failure recovery unit 120 for recovering data aftera single disk failure, and a double failure recovery unit 125 forrecovering data following concurrent failure of two disks. A diskaddition unit 130 manages the addition of new disks to the system,either after failure of an existing disk or when it is desired to expandthe system 100. The operation of each of these units is discussed ingreater detail herein below.

Each of the disks in the array 135 stores a column of data blocks. Thesame data block in successive disks forms a row, which is to say therows cross the disks. The data storage blocks are stored alongsideparity data blocks in parity disks P and Q, and the number of datablocks in the different columns or disks are different. Row parity datais placed in row parity blocks in row parity column P. Diagonal paritydata is placed in diagonal parity blocks in a diagonal parity column Q.

In the case of five data columns and four data rows, the numbers ofdiagonals is one greater than the number of rows. Hence the diagonalparity column Q comprises one more block than the other columns. Moregenerally, as will be discussed below, the max number of data columns isa prime number, and the number of rows is one less than that primenumber, creating the asymmetry discussed hereinabove. In practice thevarious columns are distributed over the physical disks available, so asnot to cause system bottlenecks.

In many embodiments, an array may comprise a plurality of solid statedrives (SSD) as opposed to magnetic disks. In various embodiments, SSDsmay be random access, whereas magnetic disks may be mechanical deviceswith momentum. In certain embodiments, the magnetic disks may be mostefficient where data readout may be largely serial and having unevensizes of columns between stripes causes the magnetic disks to workinefficiently. In some embodiments, SSDs however may be solid state withno momentum issues and thus the present embodiments may be ideallysuited to an array of SSD devices, or any other random access device.

In many embodiments, the number of data columns may equal a prime numberand the number of data rows is one less than the number of data columns,to create an asymmetry that ensures that each column is absent from oneof the diagonals.

In an embodiment, the number of data columns may be equal to a number ofdisks allowed in the array, which is the prime number referred to above.At any given time an actual number of disks present is less than orequal to the allowed number of disks, so that new disks can be addeduntil that allowed number is reached. When a disk is added, data parityblocks need to be added to the new disk to keep the parity blocks, the pand q columns, evenly spread over the physical disks to avoid systembottlenecks. Hence the controller 105 comprises a disk addition unit 130to manage the process of adding a disk to the array. In order to add anew disk to the array and maintain a balance of parity blocks over thearray, the disk addition unit 130 migrates a row parity block to the newdisk. However, in an embodiment, instead of actually writing data on thenew disk, the unit in fact retains the row parity blocks at theiroriginal disk position and defines a zeroed block of data in the newdisk to receive future parity updates for the selected row parity block.Because the original parity block is retained, zero is the currentcorrect parity for the row, so that only updates from now onwards areneeded and a resource consuming read and write is avoided. The diskaddition unit copies a single diagonal parity block to the new disksince the addition of a new disk means there is a single old diagonalparity block that does not reside in the new diagonal parity group. Therest of the diagonal parity blocks are defined as zeroed blocks of datain an identical manner to the case described above for row parityblocks, because they can be placed in positions such that they are inthe same parity group as the old diagonal parity blocks.

The controller 105 comprises a single-disk failure recovery unit 120. Abasic embodiment recovers the data of the entire disk using row parityonly or diagonal parity only. However a more efficient embodiment usesrow parity to recover just some, typically half, or the lost data blocksand then switches to diagonal parity to recover the remaining datablocks. The switch to diagonal parity means that data blocks alreadyread to recover row parity data can be reused and thus the entire diskcan be recovered with considerably fewer read operations.

A double-disk failure recovery unit 125 is used to recover datafollowing failure of two of the disks. The unit selects a first blockfor recovery from one of the disks, where the block's diagonal parityincludes that block but does not include any blocks from the othermissing column. The unit recovers this first block using the diagonalparity. The unit then recovers the block of the same row in the secondmissing disk using the row parity. The unit continues to alternatebetween diagonal and row parity until all the rows are recovered.

The data update unit 115 writes a new data block over an old data block.The data update unit reads the old data block, and existing parity data,then writes the new data block and XORs data of the old data block withdata of the new data block and the existing parity data to form newparity data. There is no need to read the other data blocks in the samerow or column since they remain unchanged, meaning their parity remainsunchanged.

Now consider in greater detail, the present embodiments reduce systemoverheads at the expense of capacity. A block is added to contain theparity of the kth diagonal. This leads to the disadvantage of havingcolumns which are different sizes, and thus disks which are differentsizes. In fact the different sized disk problems can be avoided if theblocks are spread over disks in such a way as to provide no noticeabledifference. Spreading over different disks has the added advantage ofprevent bottleneck creation, as discussed with the existing schemes.

A Raid 6 scheme based on magnetic disks requires sequential disk actionsand the absence of an even disk layout means that the tendency of diskactions to be sequential is lost. However when working with SSDs whichare much more random access, data access can be in any desired sequencewithout any issue of mechanical inertia.

An SSD is a data storage device that uses solid-state memory to storepersistent data with the intention of providing access in the samemanner of a traditional block I/O hard disk drive. SSDs aredistinguished from traditional hard drives (HDDs), which areelectromechanical devices containing spinning disks and movableread/write heads. In contrast, SSDs use microchips which retain data innon-volatile memory chips and contain no moving parts. Compared toelectromechanical HDDs, SSDs are typically less susceptible to physicalshock, are silent, have lower access time and latency, but are manytimes more expensive per gigabyte (GB). SSDs use the same interface ashard disk drives, thus easily replacing them in most applications.

At present, SSDs use NAND-based flash memory, which retains memory evenwithout power. SSDs using volatile random-access memory (RAM) also existfor situations which require even faster access, but do not necessarilyneed data persistence after power loss, or use external power orbatteries to maintain the data after power is removed.

The scheme present being outlined also requires more space forredundancy than other RAID6 schemes. For example, in an embodiment, letK represent a number of total number of data disks within a RAID6Scheme. As K gets larger, the additional overhead gets smaller so thatthis particular disadvantage is manageable.

Refer to the example embodiment of FIG. 2, which is a simplifiedschematic diagram of the present embodiment, in the case shown, k is 5,a prime number, and there are five columns, (D0-D4). There are four rows(k−1). The P column consists of the same four rows but the Q column hasan extra row.

The block size may be defined as 4K. The same scheme is shown in FIG. 3,in which the individual data blocks are defined. FIG. 3 shows whichparity blocks are associated with each respective data block. Forexample, in this embodiment, the block showing <1, 5> may be recoveredusing parity disk block ⊕1 or ⊕5 XOR'd with every other data blockreferencing either ⊕1 or ⊕5.

The variable depth RAID scheme of the present embodiments simply adds anextra block to deal with the extra diagonal. Each stripe contains k (kmust be prime) data columns, and two parity columns P and Q. The stripeis composed of a quasi-matrix of blocks, which contains k−1 rows. ColumnP contains K−1 blocks, each consisting of the parity of the K data diskblocks in its row. The K by K−1 matrix made up of the blocks in the datacolumns contains K diagonals, each of size k−1. Column Q, in contrastwith the rest of the columns, contains k blocks and not k−1. Each of thek blocks in disk Q holds the parity of one of the diagonals.

It should be noted that the ordering of the blocks within each columnmay be arbitrary. Furthermore, the extra block in column Q may be placedin a data column which does not contain a data block in the diagonal ofwhich this block is the parity. Some of the rows may be blank.

The resulting code is optimal under nearly all operations with respectto I/Os and computations, excluding the reads needed to rebuild a diskafter one failure. The rebuild overhead after one disk failure can bebrought down to a bit more than 3K/4 reads, midway between the optimalof k/2 and the k reads needed by Even/Odd and RDP. The extra blockcauses the capacity overhead to grow slightly, but this overhead of1/(K²−K) can be made as small as required by increasing K. Anotherproblem this extra block may pose is that Q is larger than the rest ofthe columns. This is easily fixed by using a configuration where theparity columns of each stripe are balanced across the various disks.This configuration balances both I/Os and capacity utilization betweenthe physical disks.

More information regarding RAID implementations may be found in U.S.Pat. No. 8,990,495 entitled “Secure data storage in RAID Memory Devices”which is commonly assigned herewith and incorporated by referenceherein.

Updated RAID 6 Implementation

In many embodiments, the current disclosure may enable implementation ofa simplified RAID 6 scheme. In various embodiments, the currentdisclosure may enable implementation of a RAID 6 scheme that may reduceread latency in the case of a single or a double disk failure. Incertain embodiments, the current disclosure may enable recovery withoutrequiring reading a large part of a data stripe within a RAID 6 schemebefore recovering a single data block of a failed disk.

In most embodiments, the current disclosure may enable implementation ofa RAID 6 scheme without an extra Q parity block. In various embodiments,the current disclosure may enable an updated RAID 6 implementationwithout an extra Q parity block to reduce the read penalty in the caseof a double disk failure of a data disk and parity disk failure, byallowing recovery of data blocks by reading at most 2*p+1 blocks, andreduce the write overhead of parities update even on writing singleblock to 3 writes.

In many embodiments, the current disclosure may keep parity of each datacolumn in the Q column such that extra data may be used during therecovery process. In various embodiments, extra stored in the Q columnmay replace the role of an extra Q.

In most embodiments, the following definitions may be useful. In certainembodiments, Let S be a stripe and mark S_(i,j):=“the block in row icolumn j”. In these embodiments, for every disk j column of the stripelet d_(j):=⊕_(i=1) ^(p−1)S_(i,j). In these embodiments, ∀iε{1 . . . p−1}define p_(i):=“parity of row i”. In these embodiments, q_(i):=“parity ofdiagonal i” by diagonal i may refer to the diagonal that is notintersecting with column i. In these embodiments, let q_(p) be the extraQ. In these embodiments, define q _(k):=q_(k) ⊕d_(k).

In many embodiments, given P and Q a updated RAID 6 implementation maybe enabled to recover from a double failure. In various embodiments, ifa data disk and a Q parity disk fails, recovery in an updated RAID 6Implementation may continue as normal.

In certain embodiments, if data disk i≠p and P disk fail, d₁ is knownfor all i≠j, and d_(i) can be recovered from q _(i) since the diagonal iis not intersecting column i thus q_(i) is known. In some embodiments,XOR'ing out the d_(j) from Q bring us to the known recovery formula. Incertain embodiments, if i=p then Q is known since all d_(j) are, andeach block may be recovered from diagonal.

In most embodiments, if two data disks fail (disk i and disk j) whereneither failed disk is the parity disk P, an updated RAID 6implementation may be enabled to recover the blocks using two steps. Invarious embodiments, a first step may include partially recovering eachblock.Ŝ _(k,i) =S _(k,i)⊕{either d _(i) or d _(j)}Ŝ _(k,j) =S _(k,j)⊕{either d _(i) or d _(j)}In certain embodiments, a second step may include XOR out d_(i) andd_(i) to get the data block S_(k), and S_(k,j). In various embodiments,since p−1 is even, r and p−1−r are even\odd together, if r is even thanXOR on all blocks of the column i will eliminate d_(j) and d_(i) andthus we will get d_(i) and in the same way we can get d_(j), and thusrecover the data. In certain embodiments, if r is odd, than we get⊕_(i=1) ^(r)S_(k) _(i) _(,j)⊕_(i=r+1) ^(p−1−r)S_(k) _(i)_(,j)⊕d_(j)⊕d_(i)=d_(i) thus we get d_(i) and d_(j) and we may continuerecovery. In some embodiments, the case of i=p is just a special casewith r=0.

In most embodiments, an updated RAID 6 implementation may provideadvantages. In various embodiments, a parity disk failure may cause, atmost, reading 2*P+1 blocks for double-degraded read. In certainembodiments, upon write of single block at most 3 parities may beupdated (row parity, diagonal parity, and the diagonal XOR'd with thecolumn parity).

Refer to the example embodiment of FIG. 4. FIG. 4 is a simplifiedillustration of a Redundant Array of Independent Disks (RAID) 6implementation on a Raid system, in accordance to an embodiment of thepresent disclosure. As shown, Raid system 400 includes raid controller405 and raid array 435. Raid array 435 includes data disks D0, D1, D2,D3, D4,D5, parity disk P, and parity disk Q. As shown, each of the datastorage disks on Raid array 435 are the same size.

Raid controller 405 includes data writing unit 410, data update unit415, single failure recovery unit 420, double recovery unit 425, anddisk addition unit 430. Data writing unit 410 is enabled to handleinitial data writes to raid array 435. Data update unit 415 is enabledto handle updates to data already stored on raid array 435. Singlefailure recovery unit 420 is enabled to handle recovery of a failure ofa single disk within raid array 435. double recovery unit 425 is enabledto handle failure of two disks within array 435. Disk addition unit 430is enabled to handle either replacement of a failed disk within RAIDarray 435 or addition or more disks within raid array 435 to increasethe storage size of raid system 400.

Refer to the example embodiments of FIGS. 5A and 5B. FIGS. 5A and 5B aresimplified illustrations of a striping pattern of a Redundant Array ofIndependent Disk (RAID) implementation, in accordance to an embodimentof the present disclosure. As shown in FIG. 5A, data is striped acrossdata storage disks D1-D5 using five columns and four rows of data.Parity disk P is enabled to store parity data for each respective row.Parity disk Q is enabled to store a combination of diagonal parity dataand column parity data.

As shown in FIG. 5B, each of the data blocks within data storage disksD1-D5 show which parity blocks are associated with each data block. Forexample, data block (row 1, column 1) shows “<1,5>” which indicates thatparity blocks “⊕1” and “⊕5” may be used to recover data within that datablock. In this embodiment, each row parity data block is associated withdata blocks in each respective row within data storage disks D1-D5.Diagonal and column parity disk includes diagonal parity data and columnparity data XOR'd together.

Refer to the example embodiment of FIGS. 4 and 6. FIG. 6 is a simplifiedflowchart of a method of storing data within a RAID system as shown inFIG. 4, in accordance with an embodiment of the present disclosure. FIG.4 shows Raid System 400 which includes raid controller 405 and raidarray 435. raid controller 405 manages data received from host 445 andstores the data on raid 435 using data writing unit 410, data updateunit 415, single failure recovery unit 420, double recovery unit 425,and disk addition unit 430.

In this embodiment, raid system 400 receives a request to store datafrom host 445 (Step 600). raid controller 405 utilizes data writing unit410 to write data blocks to disks D0-D4 of raid array 435 (Step 610).Data writing unit 410 calculates parity blocks to be stored on paritydisk P and parity disk Q (Step 620), which includes creating row parityblocks, diagonal parity blocks, and column parity blocks. Data writingunit 410 creates modified diagonal parity blocks (Step 630) by combiningdiagonal parity blocks and column parity blocks. Disk writing unit 410then writes the row parity blocks to parity disk P and the combineddiagonal column parity blocks to parity disk Q (Step 640).

General

The methods and apparatus of this invention may take the form, at leastpartially, of program code (i.e., instructions) embodied in tangiblenon-transitory media, such as floppy diskettes, CD-ROMs, hard drives,random access or read only-memory, or any other machine-readable storagemedium.

FIG. 7 is a block diagram illustrating an apparatus, such as a computer710 in a network 700, which may utilize the techniques described hereinaccording to an example embodiment of the present invention. Thecomputer 710 may include one or more I/O ports 702, a processor 703, andmemory 704, all of which may be connected by an interconnect 725, suchas a bus. Processor 703 may include program logic 705. The I/O port 702may provide connectivity to memory media 783, I/O devices 785, anddrives 787, such as magnetic drives, optical drives, or Solid StateDrives (SSD). When the program code is loaded into memory 704 andexecuted by the computer 710, the machine becomes an apparatus forpracticing the invention. When implemented on one or moregeneral-purpose processors 703, the program code combines with such aprocessor to provide a unique apparatus that operates analogously tospecific logic circuits. As such, a general purpose digital machine canbe transformed into a special purpose digital machine.

FIG. 8 is a block diagram illustrating a method embodied on a computerreadable storage medium 860 that may utilize the techniques describedherein according to an example embodiment of the present invention. FIG.8 shows Program Logic 855 embodied on a computer-readable medium 860 asshown, and wherein the Logic is encoded in computer-executable codeconfigured for carrying out the methods of this invention and therebyforming a Computer Program Product 800. Program Logic 855 may be thesame logic 705 on memory 704 loaded on processor 703 in FIG. 7. Theprogram logic may be embodied in software modules, as modules, ashardware modules, or on virtual machines.

The logic for carrying out the method may be embodied as part of theaforementioned system, which is useful for carrying out a methoddescribed with reference to embodiments shown in, for example, FIGS.1-8. For purposes of illustrating the present invention, the inventionis described as embodied in a specific configuration and using speciallogical arrangements, but one skilled in the art will appreciate thatthe device is not limited to the specific configuration but rather onlyby the claims included with this specification.

Although the foregoing invention has been described in some detail forpurposes of clarity of understanding, it will be apparent that certainchanges and modifications may be practiced within the scope of theappended claims. Accordingly, the present implementations are to beconsidered as illustrative and not restrictive, and the invention is notto be limited to the details given herein, but may be modified withinthe scope and equivalents of the appended claims.

What is claimed is:
 1. A computer-executable method of implementing aredundant array of independent disk (RAID) system wherein the RAID, thecomputer-executable method comprises: storing data storage blocksarranged in a first plurality of data rows and a second plurality ofdata columns; and storing parity data in defined parity blocks, whereina portion of the defined parity blocks include column parity data;wherein each, column parity data is combined with a row of diagonalparity data wherein the row of diagonal parity data is not associatedwith the column parity data.
 2. The computer-executable method of claim1, wherein at least some of said parity data is row parity data placedin row parity blocks in a row parity column.
 3. The computer-executablemethod of claim 1, wherein at least some of said parity data is diagonalparity data placed in diagonal parity blocks in a diagonal paritycolumn.
 4. The computer-executable method of claim 3, wherein thediagonal parity data is combined with column parity data.
 5. Thecomputer-executable method of claim 3, wherein the number of data rowsequals a number of rows of the row parity data and the number of rows ofdiagonal parity data.
 6. A system, comprising: a data storage systemimplementing a Redundant Array of Independent Disks (RAID); andcomputer-executable program logic encoded in memory of one or morecomputers enabled to implement RAID 6 on the data storage system,wherein the computer-executable program logic is configured for theexecution of: storing data storage blocks arranged in a first pluralityof data rows and a second plurality of data columns; and storing paritydata in defined parity blocks, wherein a portion of the defined parityblocks include column parity data; wherein each column parity data iscombined with a row of diagonal parity data wherein the row of diagonalparity data is not associated with the column parity data.
 7. The systemof claim 6, wherein at least some of said parity data is row parity dataplaced in row parity blocks in a row parity column.
 8. The system ofclaim 6, wherein at least some of said parity data is diagonal paritydata placed in diagonal parity blocks in a diagonal parity column. 9.The system of claim 8, wherein the diagonal parity data is combined withcolumn parity data.
 10. The system of claim 8, wherein the number ofdata rows equals a number of rows of the row parity data and the numberof rows of diagonal parity data.
 11. A computer program product forimplementing a Redundant array of independent disk (RAID) system, thecomputer program product comprising: a non-transitory computer readablemedium encoded with computer-executable code, the code configured toenable the execution of: storing data storage blocks arranged in a firstplurality of data rows and a second plurality of data columns; andstoring parity data in defined parity blocks, wherein a portion of thedefined parity blocks include column parity data; wherein each columnparity data is combined with a row of diagonal parity data wherein therow of diagonal parity data is not associated with the column paritydata.
 12. The computer program product of claim 11, wherein at leastsome of said parity data is row parity data placed in row parity blocksin a row parity column.
 13. The computer program product of claim 11,wherein at least some of said parity data is diagonal parity data placedin diagonal parity blocks in a diagonal parity column.
 14. The computerprogram product of claim 13, wherein the diagonal parity data iscombined with column parity data.
 15. The computer program product ofclaim 13, wherein the number of data rows equals a number of rows of therow parity data and the number of rows of diagonal parity data.